{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Custom Distributions\n",
    "\n",
    "author: Jacob Schreiber <br>\n",
    "contact: jmschreiber91@gmail.com\n",
    "\n",
    "One of the main implementation details of pomegranate is that it decouples the mathematics behind the various models from the likelihood functions that are used in them. For example, the class probabilities calculated for mixture models and Bayes' classifiers involve multiplying a likelihood function and a prior probability. Typically, this likelihood function is assumed to be Gaussian, but there is no algorithmic requirement that it be any specific probability distribution. This is why pomegranate is much more flexible than other packages in terms of the types of distributions that various models can be built using.\n",
    "\n",
    "However, a major limitation in pomegranate for a long time was that while users were free to use any of the built in distributions to build models, they could not define their own in Python. The reason behind this is the Cython backend, which essentially required that the distributions be implemented in Cython.\n",
    "\n",
    "Fortunatly, a recent patch has allowed users to define their own custom distributions. This means that users can define their own distributions, entirely in Python, and plug them in to existing models without modification. This tutorial will show you how to do that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fri Jan 10 2020 \n",
      "\n",
      "numpy 1.18.1\n",
      "scipy 1.4.1\n",
      "pomegranate 0.12.0\n",
      "\n",
      "compiler   : Clang 10.0.0 (clang-1000.11.45.5)\n",
      "system     : Darwin\n",
      "release    : 17.7.0\n",
      "machine    : x86_64\n",
      "processor  : i386\n",
      "CPU cores  : 4\n",
      "interpreter: 64bit\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import time\n",
    "import pandas\n",
    "import random\n",
    "import numpy\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set_style('whitegrid')\n",
    "import itertools\n",
    "\n",
    "from pomegranate import *\n",
    "\n",
    "random.seed(0)\n",
    "numpy.random.seed(0)\n",
    "numpy.set_printoptions(suppress=True)\n",
    "\n",
    "%load_ext watermark\n",
    "%watermark -m -n -p numpy,scipy,pomegranate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a new normal distribution\n",
    "\n",
    "Let's start off by building a custom normal distribution. Our goal is to build a pure Python object that has the exact same functionality as the normal distribution that is currently implemented, to demonstrate that the internals are all working correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats\n",
    "\n",
    "class NormalDistribution2():\n",
    "    def __init__(self, mu, std):\n",
    "        self.mu = mu\n",
    "        self.std = std\n",
    "        self.parameters = (self.mu, self.std)\n",
    "        self.d = 1\n",
    "        self.summaries = numpy.zeros(3)\n",
    "\n",
    "    def log_probability(self, X):\n",
    "        return scipy.stats.norm.logpdf(X, self.mu, self.std)\n",
    "\n",
    "    def summarize(self, X, w=None):\n",
    "        if w is None:\n",
    "            w = numpy.ones(X.shape[0])\n",
    "\n",
    "        X = X.reshape(X.shape[0])\n",
    "        self.summaries[0] += w.sum()\n",
    "        self.summaries[1] += X.dot(w)\n",
    "        self.summaries[2] += (X ** 2.).dot(w)\n",
    "\n",
    "    def from_summaries(self, inertia=0.0):\n",
    "        self.mu = self.summaries[1] / self.summaries[0]\n",
    "        self.std = self.summaries[2] / self.summaries[0] - self.summaries[1] ** 2 / (self.summaries[0] ** 2)\n",
    "        self.std = numpy.sqrt(self.std)\n",
    "        self.parameters = (self.mu, self.std)\n",
    "        self.clear_summaries()\n",
    "\n",
    "    def clear_summaries(self, inertia=0.0):\n",
    "        self.summaries = numpy.zeros(3)\n",
    "\n",
    "    @classmethod\n",
    "    def from_samples(cls, X, weights=None):\n",
    "        d = NormalDistribution2(0, 0)\n",
    "        d.summarize(X, weights)\n",
    "        d.from_summaries()\n",
    "        return d\n",
    "\n",
    "    @classmethod\n",
    "    def blank(cls):\n",
    "        return NormalDistribution2(0, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The custom objects have a few requirements.\n",
    "\n",
    "(1) An attribute, `d`, that stores the number of dimensions represented by the distribution. For univariate distributions like this normal distribution, this should just be 1.\n",
    "\n",
    "\n",
    "(2) A method, `log_probability(X)`, that takes in a vector of shape (n_samples,) or a matrix of shape (n_samples, d) if multivariate, and returns the log probability of each sample. In this case we're just using the built-in scipy function for calculating log probabilities under a normal distribution for simplicity.\n",
    "\n",
    "(3) A method, `summarize(X, weights=None)`, that takes in a vector of shape (n_samples,) or a matrix of shape (n_samples, d) if multivariate, calculates the sufficient statistics of that batch, and adds them to the growing sufficient statistics. In the case of a normal distribution, our sufficient statistics are the sum of the weights, the sum of the weighted points, and the sum of the weighted points squared. \n",
    "\n",
    "(4) A method, `from_summaries(inertia=0.0)`, that takes uses the stored sufficient statistics in order to update the model parameters. This should also clear the stored sufficient statistics for the next iteration of training.\n",
    "\n",
    "(5) A method, `clear_summaries()`, that clears the stored sufficient statistics. Here, all we're doing is resetting the three stored summaries to 0.\n",
    "\n",
    "(6) A class method, `from_samples(X, weights=None)` that rreturns a distribution that has been fit to the data. Generally this will initialize a dummy distribution and then overwrite the initial parameters using those derived from the data.\n",
    "\n",
    "(7) A class method, `blank()` or `blank(d)` if multivariate, that creates a dummy distribution with the appropriate number of parameters. Here we return a distribution with a mean and a variance of 0. These dummies generally aren't meant to be used.\n",
    "\n",
    "Let's test this against the built in distributions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-77.23179709134088, -77.23179709134129)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NormalDistribution(2.532, 8.211).log_probability(102.563), NormalDistribution2(2.532, 8.211).log_probability(102.563)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks good so far. Looks like there might be a small difference at very smalll precisions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.8729100873003006, 0.5756744412108401]\n",
      "(0.8729100873002954, 0.5756744412108428)\n"
     ]
    }
   ],
   "source": [
    "X = numpy.random.normal(0.872, 0.57721, size=100000)\n",
    "\n",
    "print(NormalDistribution.from_samples(X).parameters)\n",
    "print(NormalDistribution2.from_samples(X).parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! Now let's try putting this into a more complex model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] Improvement: 27.262773607714053\tTime (s): 0.000407\n",
      "[2] Improvement: 8.072984397975915\tTime (s): 0.0006638\n",
      "[3] Improvement: 3.6296182644623514\tTime (s): 0.0005722\n",
      "[4] Improvement: 1.9879748588534767\tTime (s): 0.0005398\n",
      "[5] Improvement: 1.2248102842011122\tTime (s): 0.0005431\n",
      "Total Improvement: 42.17816141320691\n",
      "Total Time (s): 0.0040\n"
     ]
    }
   ],
   "source": [
    "X = numpy.random.normal(0, 1, size=(1000, 1))\n",
    "X[::2] += 1\n",
    "\n",
    "model1 = GeneralMixtureModel.from_samples(NormalDistribution, 2, X, max_iterations=5, init='first-k', verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] Improvement: 27.26277360771337\tTime (s): 0.002283\n",
      "[2] Improvement: 8.072984397971823\tTime (s): 0.002548\n",
      "[3] Improvement: 3.6296182644625787\tTime (s): 0.002187\n",
      "[4] Improvement: 1.9879748588559778\tTime (s): 0.002138\n",
      "[5] Improvement: 1.2248102842013395\tTime (s): 0.002576\n",
      "Total Improvement: 42.17816141320509\n",
      "Total Time (s): 0.0160\n"
     ]
    }
   ],
   "source": [
    "model2 = GeneralMixtureModel.from_samples(NormalDistribution2, 2, X, max_iterations=5, init='first-k', verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1528.71286897159, -1528.712868971989)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model1.log_probability(X).sum(), model2.log_probability(X).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! It looks like both for fitting a mixture model and performing inference that our new Python distribution is identical to the built-in one. Now, how much slower is it to use the Python object versus the Cython one?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.64 s ± 102 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "12.1 s ± 737 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "X = numpy.random.normal(0, 1, size=(300000, 1))\n",
    "X[::2] += 1\n",
    "\n",
    "%timeit GeneralMixtureModel.from_samples(NormalDistribution, 2, X, max_iterations=100, init='first-k')\n",
    "%timeit GeneralMixtureModel.from_samples(NormalDistribution2, 2, X, max_iterations=100, init='first-k')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like it can be a fair bit slower. Another drawback of using a Python distibution is that it may be less efficient to do multi-threaded parallelism, because the Python object requires the GIL. However, many numpy operations will drop the GIL and so can actually be used with multi-threading, but that isn't guaranteed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6 s ± 7.76 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "12 s ± 720 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit GeneralMixtureModel.from_samples(NormalDistribution, 2, X, max_iterations=100, init='first-k', n_jobs=2)\n",
    "%timeit GeneralMixtureModel.from_samples(NormalDistribution2, 2, X, max_iterations=100, init='first-k', n_jobs=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This distribution acts exactly like any other distribution. If we want to use a different distribution to model different features, we can use a mix of custom and built-in distrbutions with ease."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] Improvement: 23.311879238614438\tTime (s): 0.1243\n",
      "[2] Improvement: 6.699529281400373\tTime (s): 0.1171\n",
      "[3] Improvement: 3.0210554091190716\tTime (s): 0.1278\n",
      "[4] Improvement: 1.7027921401574986\tTime (s): 0.1284\n",
      "[5] Improvement: 1.0990971926314614\tTime (s): 0.128\n",
      "[6] Improvement: 0.7793100178469103\tTime (s): 0.1179\n",
      "[7] Improvement: 0.5912596644188852\tTime (s): 0.1501\n",
      "[8] Improvement: 0.468752338889999\tTime (s): 0.1177\n",
      "[9] Improvement: 0.3796901625521514\tTime (s): 0.1326\n",
      "[10] Improvement: 0.30861288860546665\tTime (s): 0.1318\n",
      "[11] Improvement: 0.24885399990603219\tTime (s): 0.1276\n",
      "[12] Improvement: 0.19804543157511034\tTime (s): 0.1194\n",
      "[13] Improvement: 0.15545944917175802\tTime (s): 0.1291\n",
      "[14] Improvement: 0.12065643278288007\tTime (s): 0.1178\n",
      "[15] Improvement: 0.09298774676676658\tTime (s): 0.1293\n",
      "Total Improvement: 39.1779813944388\n",
      "Total Time (s): 2.0407\n"
     ]
    }
   ],
   "source": [
    "X = numpy.random.normal(0, 1, size=(500, 3))\n",
    "X[::2] += 1\n",
    "X[:,1] = numpy.abs(X[:,1])\n",
    "\n",
    "distributions = [NormalDistribution, ExponentialDistribution, NormalDistribution2]\n",
    "model = GeneralMixtureModel.from_samples(distributions, 2, X, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a new distribution, the Student T Distribution\n",
    "\n",
    "There have been a few requests to add in the Student T distribution to pomegranate. This is, essentially, a version of the normal distribution that has a heavy tail to reduce the effect of outliers on the model. Now, instead of waiting for me to find time to add it, you can add it in yourself! Here is an example of what a custom student T distribution might look like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StudentTDistribution():\n",
    "    def __init__(self, mu, std, df=1.0):\n",
    "        self.mu = mu\n",
    "        self.std = std\n",
    "        self.df = df\n",
    "        self.parameters = (self.mu, self.std)\n",
    "        self.d = 1\n",
    "        self.summaries = numpy.zeros(3)\n",
    "\n",
    "    def probability(self, X):\n",
    "        return numpy.exp(self.log_probability(X))\n",
    "        \n",
    "    def log_probability(self, X):\n",
    "        return scipy.stats.t.logpdf(X, self.df, self.mu, self.std)\n",
    "\n",
    "    def summarize(self, X, w=None):\n",
    "        if w is None:\n",
    "            w = numpy.ones(X.shape[0])\n",
    "\n",
    "        X = X.reshape(X.shape[0])\n",
    "        self.summaries[0] += w.sum()\n",
    "        self.summaries[1] += X.dot(w)\n",
    "        self.summaries[2] += (X ** 2.).dot(w)\n",
    "\n",
    "    def from_summaries(self, inertia=0.0):\n",
    "        self.mu = self.summaries[1] / self.summaries[0]\n",
    "        self.std = self.summaries[2] / self.summaries[0] - self.summaries[1] ** 2 / (self.summaries[0] ** 2)\n",
    "        self.std = numpy.sqrt(self.std)\n",
    "        self.parameters = (self.mu, self.std)\n",
    "        self.clear_summaries()\n",
    "\n",
    "    def clear_summaries(self, inertia=0.0):\n",
    "        self.summaries = numpy.zeros(3)\n",
    "\n",
    "    @classmethod\n",
    "    def from_samples(cls, X, weights=None, df=1):\n",
    "        d = StudentTDistribution(0, 0, df)\n",
    "        d.summarize(X, weights)\n",
    "        d.from_summaries()\n",
    "        return d\n",
    "\n",
    "    @classmethod\n",
    "    def blank(cls):\n",
    "        return StudentTDistribution(0, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The primary difference between the Student T distribution and the normal distribution is the degree of freedom parameter that has to be set in advance---it is not meant to be learned from the data. The higher this parameter, the more like a normal distribution it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dn = NormalDistribution(0, 1)\n",
    "dt1 = StudentTDistribution(0, 1, 1)\n",
    "dt3 = StudentTDistribution(0, 1, 3)\n",
    "dt8 = StudentTDistribution(0, 1, 8)\n",
    "\n",
    "x = numpy.arange(-6, 6, 0.1)\n",
    "\n",
    "plt.figure(figsize=(7, 4))\n",
    "plt.plot(x, dn.probability(x), label=\"Normal\")\n",
    "plt.plot(x, dt1.probability(x), label=\"Student T, df=1\")\n",
    "plt.plot(x, dt3.probability(x), label=\"Student T, df=3\")\n",
    "plt.plot(x, dt8.probability(x), label=\"Student T, df=8\")\n",
    "plt.ylabel(\"Probability\", fontsize=12)\n",
    "plt.legend(fontsize=12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's stick it in a mixture model now and see what the normal and the Student T versions look like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = numpy.random.normal(-2, 1, size=(1000, 1))\n",
    "X[::2] += 4\n",
    "\n",
    "modeln = GeneralMixtureModel.from_samples(NormalDistribution, 2, X)\n",
    "modelt = GeneralMixtureModel.from_samples(StudentTDistribution, 2, X)\n",
    "\n",
    "x = numpy.arange(-15, 15, 0.1)\n",
    "\n",
    "plt.figure(figsize=(7, 4))\n",
    "plt.plot(x, modeln.probability(x), label=\"Normal Mixture\")\n",
    "plt.plot(x, modelt.probability(x), label=\"Student T Mixture\")\n",
    "plt.ylabel(\"Probability\", fontsize=12)\n",
    "plt.legend(fontsize=12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The results look reasonable. The Student T distributions have a smaller valley separating the peaks because they have heavier tails. Additionally, the peaks are closer together for the Student T distribution because the heavier tails assign more credit from points in one cluster to the distribution modeling the other cluster. This pulls the centers together slightly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Block Distributions\n",
    "\n",
    "Currently, pomegranate supports distributions where the features are either independent, through `IndependentComponentsDistribution`, or have a Gaussian covariance structure, as in `MultivariateGaussianDistribution`. However, sometimes one would want to model their features in blocks, where the covariance amongst features in the block are accounted for. When all your variables are Gaussian, this is simply having an enforced block structure on your covariance matrix. In the more general case, this can take the form of a Bayesian network. \n",
    "\n",
    "This new custom support allows us to do that easily. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BlockGaussianDistribution():\n",
    "    def __init__(self, distributions):\n",
    "        self.distributions = distributions\n",
    "        self.d = sum([d.d for d in distributions])\n",
    "        \n",
    "    def log_probability(self, X):\n",
    "        i, log_probability = 0, numpy.zeros(X.shape[0])\n",
    "        for distribution in self.distributions:\n",
    "            log_probability += distribution.log_probability(X[:, i:i+distribution.d].copy())\n",
    "            i += distribution.d\n",
    "        return log_probability\n",
    "    \n",
    "    def summarize(self, X, w=None):\n",
    "        i = 0\n",
    "        for distribution in self.distributions:\n",
    "            distribution.summarize(X[:, i:i+distribution.d].copy(), w)\n",
    "            i += distribution.d\n",
    "    \n",
    "    def from_summaries(self, inertia=0.0):\n",
    "        for distribution in self.distributions:\n",
    "            distribution.from_summaries(inertia)\n",
    "\n",
    "    @classmethod\n",
    "    def from_samples(cls, X, weights=None, ds=[]):\n",
    "        distributions = [MultivariateGaussianDistribution.blank(d) for d in ds]\n",
    "        d = BlockGaussianDistribution(distributions)\n",
    "        d.summarize(X, weights)\n",
    "        d.from_summaries()\n",
    "        return d\n",
    "\n",
    "    @classmethod\n",
    "    def blank(cls, ds):\n",
    "        distributions = [MultivariateGaussianDistribution.blank(d) for d in ds]\n",
    "        return BlockGaussianDistribution(distributions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code above, `BlockGaussianDistribution` creates multiple `MultivariateGaussianDistribution` objects, each modeling a different set of features. The probability of an example is then the product of the probability of each set of features under their respective distribution.\n",
    "\n",
    "To evaluate this, let's look at the diabetes data set. This is normally a regression task, so we'll have to binarize the response using the median value. Additionally, the data has been scaled for us already, so we'll have to go ahead an unscale it for the purposes of our demonstration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_diabetes\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from pomegranate import LogNormalDistribution, BernoulliDistribution, NormalDistribution\n",
    "\n",
    "data = load_diabetes()\n",
    "X, y = data.data, data.target\n",
    "X[:,1] = (X[:,1] - X[:,1].min()) / (X[:,1].max() - X[:,1].min())\n",
    "X[:,0] -= X[:,0].min() - 0.001\n",
    "X[:,2] -= X[:,2].min() - 0.001\n",
    "X[:,3] -= X[:,3].min() - 0.001\n",
    "y = y > numpy.median(y)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first four variables correspond to age, sex, BMI, and average blood pressure. The remaining six features are different blood serum measurements. In this example, let's use univariate distributions to model the first four variables, and a multivariate Gaussian with a full covariance matrix to model the last six.\n",
    "\n",
    "To get a sense for what distributions might be a good fit for the first four features, we can visualize the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ksachdeva/Desktop/Dev/myoss/pomegranate/env/lib/python3.7/site-packages/ipykernel_launcher.py:11: MatplotlibDeprecationWarning: \n",
      "The 'normed' kwarg was deprecated in Matplotlib 2.1 and will be removed in 3.1. Use 'density' instead.\n",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x144 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "names = 'Age', 'Sex', 'BMI', 'Average Blood Pressure'\n",
    "plt.figure(figsize=(14, 2))\n",
    "\n",
    "for i in range(4):\n",
    "    plt.subplot(1, 4, i+1)\n",
    "    \n",
    "    x = numpy.arange(0.01, 0.3 if i != 1 else 1, 0.01)\n",
    "    \n",
    "    plt.hist(X_train[:,i], bins=10, normed=True)\n",
    "    plt.plot(x, LogNormalDistribution.from_samples(X_train[:,i]).probability(x), label=\"LogNormal\")\n",
    "    plt.plot(x, NormalDistribution.from_samples(X_train[:,i]).probability(x), label=\"Normal\")\n",
    "    plt.title(names[i], fontsize=12)\n",
    "    \n",
    "plt.legend(loc=(1.05, 0.4))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like age and BMI may be better modeled by a normal distribution than a log normal distribution, but that average blood pressure is better modeled with a log normal distribution. Due to the binary nature of sex in this data set, a Bernoulli distribution seems like the right choice.\n",
    "\n",
    "Let's now train a Bayes' classifier using our custom block distribution! To evaluate its performance, let's compare against a model that simply uses a single multivariate Gaussian distribution per class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7303370786516854, 0.6966292134831461)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds = [BlockGaussianDistribution([NormalDistribution.blank(),\n",
    "                                 BernoulliDistribution.blank(),\n",
    "                                 NormalDistribution.blank(),\n",
    "                                 LogNormalDistribution.blank(),\n",
    "                                 MultivariateGaussianDistribution.blank(6)]) for j in range(2)]\n",
    "model = BayesClassifier(ds)\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "model2 = BayesClassifier.from_samples(MultivariateGaussianDistribution, X_train, y_train)\n",
    "\n",
    "model.score(X_test, y_test), model2.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like the custom distribution can outperform the simpler, full covariance Gaussian, in this setting."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
